﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.Mvc;
using EFDataModel;
using EFDataModel.Enums;

namespace ContactManagement.AppCode.HtmlHelperForViews
{
    /// <summary>
    /// Erstellt die Brotkrumennavigation, abhängig vom aktuellen Kontext.
    /// </summary>
    public class BreadscrumbHtmlHelper
    {
        #region Member
        /// <summary>
        /// Der Divider der zwischen den Links gesetzt werden soll
        /// </summary>
        private string BreadScrumbDivider = " &rsaquo; ";

        /// <summary>
        /// Der aktuelle Html Helper
        /// </summary>
        private readonly HtmlHelper CurrentHtmlHelper;

        /// <summary>
        /// Der Aktuelle Controller der aus dem ViewContext ermittelt wird
        /// </summary>
        private EControllers CurrentController { get; set; }

        /// <summary>
        /// Die Aktuelle Aktion die ausgeführt wird, die ebenfalls aus dem ViewContext ermittelt wird
        /// </summary>
        private string CurrentAction { get; set; }

        /// <summary>
        /// die aktuelle Id aus der URL wenn eine existiert
        /// </summary>
        private string CurrentId { get; set; }

        /// <summary>
        /// Die Brotkrumennavigation die zusammengebaut werden soll
        /// </summary>
        private StringBuilder LinkBuilder { get; set; }

        /// <summary>
        /// ein String der einen blanken Link darstellt der in String.Format verwendet werden kann href={0}, LinkName={1}
        /// </summary>
        private const string BlankLink = "<li><a class=\"breadLink\" href=\"{0}\">{1}</a></li>";

        /// <summary>
        /// Der Aktuelle Blanklink besteht nur aus den Li elementen ohne den Link nur der Name
        /// </summary>
        private const string BlankLinkCurrent = "<li>{0}</li>";

        /// <summary>
        /// Der aktuelle UrlHelper erstellt aus dem ViewContext, zum erstellen von ActionLinks
        /// </summary>
        private UrlHelper CurrentUrlHelper { get; set; }
        #endregion

        #region Konstruktor
        /// <summary>
        /// Konstruktor der HTML Helpers Klasse für die Kategorien, die Statische Klasse zum Instanzieieren findet man in den HtmlHelperExtensions
        /// </summary>
        public BreadscrumbHtmlHelper(HtmlHelper htmlHelper)
        {
            CurrentHtmlHelper = htmlHelper;
            //den aktuellen Controller herraussuchen über den ViewContext, anhand des Controllers wird dann entschieden welche Navigation aufgebaut werden soll.
            string controllerName = CurrentHtmlHelper.ViewContext.RouteData.GetRequiredString(WebConstants.ControllerString);
            CurrentController = (EControllers)Enum.Parse(typeof(EControllers), controllerName);

            //Ermitteln welche Aktion gerade ausgeführt wird.
            CurrentAction = CurrentHtmlHelper.ViewContext.RouteData.GetRequiredString(WebConstants.ActionString);

            //die Id ist nicht immer in der URL enthalten, daher hier vorher prüfen
            if (CurrentHtmlHelper.ViewContext.RouteData.Values.ContainsKey(WebConstants.IdString))
            {
                CurrentId = CurrentHtmlHelper.ViewContext.RouteData.GetRequiredString(WebConstants.IdString);
            }

            //Wird zum Erstellen von ActionLinks benötigt
            CurrentUrlHelper = new UrlHelper(CurrentHtmlHelper.ViewContext.RequestContext);

            //Die Brotkurmennavigation wird in ein ul eingebettet.
            LinkBuilder = new StringBuilder();
            LinkBuilder.Append("<ul id=\"breadScrumb\">");

        }
        #endregion

        #region Public Functions
        /// <summary>
        /// Erstellen der Brotkrumennavigation für die aktuelle Seite.
        /// </summary>
        public MvcHtmlString CreateBreadScrumb()
        {
            //Abhängig vom aktuellen Controller wird die jeweilige Funktion aufgerufen die für den Controller die Navigationszeile aufbaut.
            switch (CurrentController)
            {
                case EControllers.Account:
                    AccountController();
                    break;

                case EControllers.Administration:
                    AdministrationController();
                    break;

                case EControllers.Error:
                    ErrorController();
                    break;

                case EControllers.Home:
                    HomeController();
                    break;

                case EControllers.User:
                    UserController();
                    break;
            }

            //Aus dem Link einen string machen und diesen dann zurück geben
            string htmlLink = LinkBuilder.Append("</ul>").ToString();
            if (htmlLink.Trim().Length > 0)
            {
                return MvcHtmlString.Create(htmlLink);
            }

            //Meldung ausgeben das keine Navigationseigenschaft für die aktuelle Position verfügbar ist, d.h. muss ausprogrammiert werden!
            return MvcHtmlString.Create(App_GlobalResources.Navigation.NoBreadScrumbNavigationAvaibleRESX);
        }
        #endregion

        #region Private Functions ContactManagement
        /// <summary>
        /// Die Brotkrumennavigation für den AccountController erstellen
        /// </summary>
        private void AccountController()
        {
            //für den AccountController die Aktion ermitteln die ausgeführt wird, denn abhängig von der aktuellen Aktion ist die aufgebaut BreadScrumb Navigation
            EActionAccount eAction = (EActionAccount)Enum.Parse(typeof(EActionAccount), CurrentAction);

            //HomeLink wird immer erstellt, für den AccountController
            AddHomeLink(false);

            //Für alle Aktionen die auch einen View haben die Brotkrumennavigation aufbauen
            switch (eAction)
            {
                //Home < Logon
                case EActionAccount.LogOn:
                    AddAccountLogonLink(true);
                    break;

                //Home < Logon < ForgottenPassword
                case EActionAccount.ForgottenPassword:
                    AddAccountLogonLink(false);
                    AddAccountForgottenPasswordLink(true);
                    break;

                //Home < Logon < ForgottenPassword < Success
                case EActionAccount.ForgottenPasswordSuccess:
                    AddAccountLogonLink(false);
                    AddAccountForgottenPasswordLink(false);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.PasswordRecoverySuccessfullyStartetRESX));
                    break;

                //Home < Logon < Register
                case EActionAccount.Register:
                    AddAccountLogonLink(false);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.RegisterRESX));
                    break;

                //Home < Logon < ForgottenPassword < ForgottenPasswordSend
                case EActionAccount.NewPasswordSend:
                    AddAccountLogonLink(false);
                    AddAccountForgottenPasswordLink(false);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.NewPasswordSendRESX));
                    break;
            }
        }

        /// <summary>
        /// Die Brotkrumennavigation für den AdministrationController erstellen
        /// </summary>
        private void AdministrationController()
        {
            //für den AdministrationController die Aktion ermitteln die ausgeführt wird, denn abhängig von der aktuellen Aktion ist die aufgebaut BreadScrumb Navigation
            EActionAdministration eAction = (EActionAdministration)Enum.Parse(typeof(EActionAdministration), CurrentAction);
            //Der Home Link existiert auf jeder Seite
            AddHomeLink(false);

            switch (eAction)
            {
                //Home < UserList < CategoryType muss ermittelt werden!!!
                case EActionAdministration.CategoriesList:
                case EActionAdministration.CategoriesEdit:
                case EActionAdministration.CategoriesAdd:
                case EActionAdministration.UserGroupsShowRights:
                case EActionAdministration.UserGroupsShowUsers:
                case EActionAdministration.UserRightsShowUsers:
                    AdministrationControllerCategories();
                    break;
            }
        }

        /// <summary>
        /// Die Kategorien werden extra behandelt, da hier in der URL die unterschiedlichen Kategorien noch einmal extra dargestellt werden
        /// siehe auch die Route Table in der global.asax
        /// </summary>
        private void AdministrationControllerCategories()
        {
            //für den AdministrationController die Aktion ermitteln die ausgeführt wird, denn abhängig von der aktuellen Aktion ist die aufgebaut BreadScrumb Navigation
            EActionAdministration eAction = (EActionAdministration)Enum.Parse(typeof(EActionAdministration), CurrentAction);
            //Um welche Kategorie es sich bei der aktuellen Anzeige handelt, wird ebenfalls in der URL angegeben und wird hier ausgelesen und ausgewertet.
            string currentCategory = CurrentHtmlHelper.ViewContext.RouteData.GetRequiredString(WebConstants.CategoryString);
            EFCategoryTypes efCategory = (EFCategoryTypes)Enum.Parse(typeof(EFCategoryTypes), currentCategory);

            //Auf die AdminuserListe kann immer zugegriffen werden
            AddAdministrationUserList(false);

            //Prüfen um welche Art der Kategorie es sich handelt die angezeigt werden soll, denn für jede Kategorie wird eine andere Leiste angezeigt.
            //Und für jede Kategorie stehen auch andere Optionen zur Verfügung
            switch (efCategory)
            {
                case EFCategoryTypes.UserCategory:
                    switch (eAction)
                    {
                        //Home < UserList < UserCategoriesList
                        case EActionAdministration.CategoriesList:
                            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UserCategoriesRESX));
                            break;

                        //Home < UserList < UserCategoriesList < CategoryAdd
                        case EActionAdministration.CategoriesAdd:
                            AddAdministrationCategoriesList(false, efCategory);
                            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.AddUserCategoryRESX));
                            break;

                        //Home < UserList < UserCategoriesList < CategoriesEdit
                        case EActionAdministration.CategoriesEdit:
                            AddAdministrationCategoriesList(false, efCategory);
                            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.EditUserCategoryRESX));
                            break;
                    }
                    break;

                case EFCategoryTypes.UserRights:
                    switch (eAction)
                    {
                        //Home < UserList < RightsList
                        case EActionAdministration.CategoriesList:
                            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UserRightsRESX));
                            break;

                        //Home < UserList < UserRights < UserRightsShowUsers
                        case EActionAdministration.UserRightsShowUsers:
                            AddAdministrationCategoriesList(false, efCategory);
                            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ManageUserRightsRESX));
                            break;
                    }
                    break;

                case EFCategoryTypes.UserGroups:
                    switch (eAction)
                    {
                        //Home < UserList < GroupList
                        case EActionAdministration.CategoriesList:
                            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UserGroupsRESX));
                            break;

                        //Home < UserList < GroupList < GroupAdd
                        case EActionAdministration.CategoriesAdd:
                            AddAdministrationCategoriesList(false, efCategory);
                            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.AddGroupRESX));
                            break;

                        //Home < UserList < GroupList < GroupEdit
                        case EActionAdministration.CategoriesEdit:
                            AddAdministrationCategoriesList(false, efCategory);
                            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.EditGroupRESX));
                            break;

                        //Home < UserList < GroupList < UserGroupShowRights
                        case EActionAdministration.UserGroupsShowRights:
                            AddAdministrationCategoriesList(false, efCategory);
                            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ManageUserRightsRESX));
                            break;

                        //Home < UserList < GroupList < UserGroupsShowUsers
                        case EActionAdministration.UserGroupsShowUsers:
                            AddAdministrationCategoriesList(false, efCategory);
                            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ManageUsersUserGroupsRESX));
                            break;
                    }
                    break;
            }
        }

        /// <summary>
        /// Die Brotkrumennavigation für den ErrorController erstellen
        /// </summary>
        private void ErrorController()
        {
            AddHomeLink(false);
            LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ErrorRESX));
        }

        /// <summary>
        /// Die Brotkrumennavigation für den HomeController erstellen
        /// </summary>
        private void HomeController()
        {
            //für den HomeController für die Aktion ermitteln die ausgeführt wird, denn abhängig von der aktuellen Aktion ist die aufgebaut BreadScrumb Navigation
            EActionHome eAction = (EActionHome)Enum.Parse(typeof(EActionHome), CurrentAction);

            switch (eAction)
            {
                //Home
                case EActionHome.Index:
                    AddHomeLink(true);
                    break;

                //Home < Impressum
                case EActionHome.Impressum:
                    AddHomeLink(false);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ImpressumRESX));
                    break;

                //Home < Contact
                case EActionHome.Contact:
                    AddHomeLink(false);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ContactFormularRESX));
                    break;

                //Home < Contact < ContactSuccess
                case EActionHome.ContactSuccess:
                    AddHomeLink(false);
                    LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionHome.Contact.ToString(), EControllers.Home.ToString()), App_GlobalResources.PageTitles.ContactFormularRESX));
                    AddDivider();
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ContactSuccessRESX));
                    break;
            }
        }

        /// <summary>
        /// Die Brotkrumennavigation für den UserController erstellen
        /// </summary>
        private void UserController()
        {
            //für den UserController für die Aktion ermitteln die ausgeführt wird, denn abhängig von der aktuellen Aktion ist die aufgebaut BreadScrumb Navigation
            EActionUser eAction = (EActionUser)Enum.Parse(typeof(EActionUser), CurrentAction);
            //Homelink ist überall vorhanden
            AddHomeLink(false);

            switch (eAction)
            {
                //Home < Details
                case EActionUser.Details:
                    AddUserDetailsLink(true);
                    break;

                //Home < Details < Edit
                case EActionUser.Edit:
                    AddUserDetailsLink(false);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.EditUserRESX));
                    break;

                //Home < Details < ChangePassword
                case EActionUser.ChangePassword:
                    AddUserDetailsLink(false);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ChangePasswordRESX));
                    break;

                //Home < Details < ChangePassword < ChangePasswordSuccess
                case EActionUser.ChangePasswordSuccess:
                    AddUserDetailsLink(false);
                    //Im Link muss die UserId mit gesezt werden für die das Password angepasst werden soll, da in der URL keine ID mit übergeben wird beim anpassen des Passwortes, muss
                    //hier die id aus der Session genommen werden, vom aktuellen User
                    LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionUser.ChangePassword.ToString(),
                                       EControllers.User.ToString(), new { id = CurrentSession.GetCurrentUser().ID }), App_GlobalResources.PageTitles.ChangePasswordRESX));
                    AddDivider();
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ChangePasswordSuccessRESX));
                    break;

                    //TODO Linkliste umbauen Stimmt nicht mehr!!!!
                //Home < UserList
                case EActionUser.UserList:
                    AddAdministrationUserList(true);
                    break;

                //Home < UserList < UserDetails
                case EActionUser.UserDetails:
                    AddAdministrationUserList(false);
                    AddAdministrationUserDetails(true, false);
                    break;

                //Home < UserList < UserDetails < UserAdd
                case EActionUser.UserAdd:
                    AddAdministrationUserList(false);
                    //Auf die Details des Nutzers kann nicht zurück gesprungen werden, da diese ID nocht nicht existiert
                    AddAdministrationUserDetails(true, true);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UserAddRESX));
                    break;

                //Home < UserList < UserDetails < UserEdit
                case EActionUser.UserEdit:
                    AddAdministrationUserList(false);
                    AddAdministrationUserDetails(false, true);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.EditUserRESX));
                    break;

                //Home < UserList < UserDetails < EditUserGroups
                case EActionUser.UserEditUserGroups:
                    AddAdministrationUserList(false);
                    AddAdministrationUserDetails(false, true);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ManageUsersUserGroupsRESX));
                    break;

                //Home < UserList < UserDetails < EditUserRights
                case EActionUser.UserEditUserRights:
                    AddAdministrationUserList(false);
                    AddAdministrationUserDetails(false, true);
                    LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UsersUserRightsManagementRESX));
                    break;
            }
        }
        #endregion

        #region Private Helpers ContactManagement
        /// <summary>
        /// Fügt den Link zur Benutzerdetailsansicht hinzu.
        /// </summary>
        /// <param name="addDivider">Gibt an ob der Divider auch im CurrentPage Modus hinzugefügt werden soll</param>
        private void AddAdministrationUserDetails(bool isCurrentPage, bool addDivider)
        {
            if (isCurrentPage)
            {
                //Wenn es sich um die aktuelle Seite handelt die angezeigt werden soll, dann wird nur der Name angezeigt und kein Link!
                LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UserDetailsRESX));
                if (addDivider)
                {
                    AddDivider();
                }
            }
            else
            {
                //Link erstellen der zu den UserDetails führt die gerade angezeigt werden, denn da wird ein bestimmter User angezeigt.
                LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionUser.UserDetails.ToString(), EControllers.Administration.ToString(), new { id = CurrentId }), App_GlobalResources.PageTitles.UserDetailsRESX));
                AddDivider();
            }
        }

        /// <summary>
        /// Fügt den Link zur Kategorienliste hinzu
        /// </summary>
        /// <param name="isCurrentPage">Gibt an ob es sich um die aktuelle Seite handelt die angezeigt wird, hier wird dann kein Link erstellt!</param>
        private void AddAdministrationCategoriesList(bool isCurrentPage, EFCategoryTypes categoryType)
        {
            //Die passende Kategorienliste anzeigen, je nachdem welche Kategorie dargestellt werden soll, denn UserGroups und UserRights sind ebenfalls Kategorien
            switch (categoryType)
            {
                case EFCategoryTypes.UserCategory:
                    if (isCurrentPage)
                    {
                        //Wenn es sich um die aktuelle Seite handelt die angezeigt werden soll, dann wird nur der Name angezeigt und kein Link!
                        LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UserCategoriesRESX));
                    }
                    else
                    {
                        LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionAdministration.CategoriesList.ToString(), EControllers.Administration.ToString(), new { category = categoryType.ToString() }), App_GlobalResources.PageTitles.UserCategoriesRESX));
                        AddDivider();
                    }
                    break;

                case EFCategoryTypes.UserGroups:
                    if (isCurrentPage)
                    {
                        //Wenn es sich um die aktuelle Seite handelt die angezeigt werden soll, dann wird nur der Name angezeigt und kein Link!
                        LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UserGroupsRESX));
                    }
                    else
                    {
                        LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionAdministration.CategoriesList.ToString(), EControllers.Administration.ToString(), new { category = categoryType.ToString() }), App_GlobalResources.PageTitles.UserGroupsRESX));
                        AddDivider();
                    }
                    break;

                case EFCategoryTypes.UserRights:
                    if (isCurrentPage)
                    {
                        //Wenn es sich um die aktuelle Seite handelt die angezeigt werden soll, dann wird nur der Name angezeigt und kein Link!
                        LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UserRightsRESX));
                    }
                    else
                    {
                        LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionAdministration.CategoriesList.ToString(), EControllers.Administration.ToString(), new { category = categoryType.ToString() }), App_GlobalResources.PageTitles.UserRightsRESX));
                        AddDivider();
                    }
                    break;
            }
        }

        /// <summary>
        /// Fügt den Link zur Administrationsstartseite hinzu, was aktuell die Userliste ist.
        /// </summary>
        /// <param name="isCurrentPage">Gibt an ob es sich um die aktuelle Seite handelt die angezeigt wird, hier wird dann kein Link erstellt!</param>
        private void AddAdministrationUserList(bool isCurrentPage)
        {
            if (isCurrentPage)
            {
                //Wenn es sich um die aktuelle Seite handelt die angezeigt werden soll, dann wird nur der Name angezeigt und kein Link!
                LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UserAdministrationRESX));
            }
            else
            {
                LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionUser.UserList.ToString(), EControllers.Administration.ToString()), App_GlobalResources.PageTitles.UserAdministrationRESX));
                AddDivider();
            }
        }
        /// <summary>
        /// Fügt den HomeLink unserer Navigation hinzu
        /// </summary>
        /// <param name="isCurrentPage">Gibt an ob es sich um die aktuelle Anzeige handelt</param>
        private void AddHomeLink(bool isCurrentPage)
        {
            if (isCurrentPage)
            {
                //Wenn es sich um die aktuelle Seite handelt die angezeigt werden soll, dann wird nur der Name angezeigt und kein Link!
                LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.Navigation.HomeLinkRESX));
            }
            else
            {
                LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionHome.Index.ToString(), EControllers.Home.ToString()), App_GlobalResources.Navigation.HomeLinkRESX));
                AddDivider();
            }
        }

        /// <summary>
        /// Fügt den Link zur Loginseite hinzufügen
        /// </summary>
        private void AddAccountLogonLink(bool isCurrentPage)
        {
            if (isCurrentPage)
            {
                //Wenn es sich um die aktuelle Seite handelt die angezeigt werden soll, dann wird nur der Name angezeigt und kein Link!
                LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.LoginRESX));
            }
            else
            {
                LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionAccount.LogOn.ToString(), EControllers.Account.ToString()), App_GlobalResources.PageTitles.LoginRESX));
                AddDivider();
            }
        }

        /// <summary>
        /// Fügt den Link zur Detailsseite des User ein für den UserController
        /// </summary>
        /// <param name="isCurrentPage">Gibt an ob es sich um die aktuelle Seite handelt die angezeigt wird, hier wird dann kein Link erstellt!</param>
        private void AddUserDetailsLink(bool isCurrentPage)
        {
            if (isCurrentPage)
            {
                //Wenn es sich um die aktuelle Seite handelt die angezeigt werden soll, dann wird nur der Name angezeigt und kein Link!
                LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.UserDetailsRESX));
            }
            else
            {
                //Wenn in der URL keine Id angegeben wurde.
                if (string.IsNullOrEmpty(CurrentId))
                {
                    //Da hier auch auf die Seite der Details zurpckgegriffen werden kann von der Passwort ändern Seite, wo keine Id in der URL mit übergeben wird, muss hier die Aktuelle UserId aus der Session genommen werden
                    LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionUser.Details.ToString(), EControllers.User.ToString(), new { id = CurrentSession.GetCurrentUser().ID }), App_GlobalResources.PageTitles.UserDetailsRESX));
                }
                else
                {
                    //Den passen Link zusammenbauen inkl. der aktuellen Aktion die ausgeführt werden soll, hier wird ein User bearbeitet, daher muss auch die UserId im Link mit angegeben werden
                    LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionUser.Details.ToString(), EControllers.User.ToString(), new { id = CurrentId }), App_GlobalResources.PageTitles.UserDetailsRESX));
                }

                AddDivider();
            }
        }

        /// <summary>
        /// Fügt den Link zur Passwort Vergessen Seite hinzufügen
        /// </summary>
        /// <param name="isCurrentPage">Gibt an ob es sich um die aktuelle Seite handelt die angezeigt wird, hier wird dann kein Link erstellt!</param>
        private void AddAccountForgottenPasswordLink(bool isCurrentPage)
        {
            if (isCurrentPage)
            {
                //Wenn es sich um die aktuelle Seite handelt die angezeigt werden soll, dann wird nur der Name angezeigt und kein Link!
                LinkBuilder.Append(string.Format(BlankLinkCurrent, App_GlobalResources.PageTitles.ForgottenPasswordRESX));
            }
            else
            {
                LinkBuilder.Append(string.Format(BlankLink, CurrentUrlHelper.Action(EActionAccount.ForgottenPassword.ToString(), EControllers.Account.ToString()), App_GlobalResources.PageTitles.ForgottenPasswordRESX));
                AddDivider();
            }
        }
        #endregion

        #region Private Allgemeine Helper
        /// <summary>
        /// Fügt den Divider am Ende des aktuellen Links an
        /// </summary>
        private void AddDivider()
        {
            LinkBuilder.Append(BreadScrumbDivider);
        }
        #endregion
    }
}